Digital image processing

1. Introduccion 🃏

1.1 Que es el Procesamiento digital de imágenes (Digital image processing)

  • El procesamiento de imĆ”genes digitales es el conjunto de tĆ©cnicas que se aplican a las imĆ”genes digitales con el objetivo de mejorar la calidad o facilitar la bĆŗsqueda de información.

    Para saber mas ver: opencv

In [2]:
import cv2 #OpenCV
import numpy as np #Vectores y matrices
from matplotlib import pyplot as plt #GrƔficos

from IPython.display import Image #Plotiar imagenes de una manera ams facil

2.1 OpenCV 📗


Instalación

pip install opencv-python

Descripción

OpenCV (Open Source Computer Vision Library) es una biblioteca de software de visión artificial y aprendizaje automÔtico de código abierto. OpenCV se creó para proporcionar una infraestructura común para aplicaciones de visión por computadora y para acelerar el uso de la percepción de mÔquinas en los productos comerciales.

La biblioteca tiene mÔs de 2500 algoritmos optimizados, que incluyen un conjunto integral de algoritmos de visión por computadora y aprendizaje automÔtico tanto clÔsicos como de última generación. Estos algoritmos se pueden usar para detectar y reconocer caras, identificar objetos, clasificar acciones humanas en videos, rastrear movimientos de cÔmara, rastrear objetos en movimiento, extraer modelos 3D de objetos, producir nubes de puntos 3D desde cÔmaras estéreo, unir imÔgenes para producir una alta resolución imagen de una escena completa, encuentre imÔgenes similares de una base de datos de imÔgenes, elimine los ojos rojos de las imÔgenes tomadas con flash, siga los movimientos de los ojos, reconozca los paisajes y establezca marcadores para superponerlos con realidad aumentada, etc.

Link

Open CV

2.2 numpy 📗


Instalación

conda install -c anaconda -y numpy

Descripción

Numpy es una biblioteca para el lenguaje de programación Python que (entre otras cosas) brinda soporte para grandes matrices multidimensionales.

¿Por qué es eso importante? Usando NumPy, podemos expresar imÔgenes como matrices multidimensionales.

Representar imƔgenes como matrices NumPy no solo es computacional y eficiente en el uso de recursos, sino que muchas otras bibliotecas de procesamiento de imƔgenes y aprendizaje automƔtico tambiƩn usan representaciones de matrices NumPy. AdemƔs, al usar las funciones matemƔticas de alto nivel incorporadas de NumPy, podemos realizar rƔpidamente anƔlisis numƩricos en una imagen.

Link

Numpy

2.3 Matplotlib 📗


Instalación

conda install -c conda-forge -y matplotlib

Descripción

Matplotlib es una biblioteca para la generación de grÔficos a partir de datos contenidos en listas o arreglos en el lenguaje de programación Python y su extensión matemÔtica NumPy.

Por medio del comando mƔgico %matplotlib inline se indica que los despliegues grƔficos de la biblioteca matplotlib se despliegan en el cuaderno Jupyter directamente.

Link

Matplotlib

3.1 Paths


In [3]:
image1_path = './images/lenna_main.jpg'
image2_path = './images/lena.bmp'
In [4]:
Image(filename=image1_path) 
Out[4]:
In [10]:
# Imagen a color.
img_color = cv2.imread(image1_path, cv2.IMREAD_COLOR)
print("La resolución de la imagen es {}".format(img_color.shape))

# Transformar imagen BGR a RGB.
img_color = cv2.cvtColor(img_color, cv2.COLOR_BGR2RGB)

plt.imshow(img_color)
plt.title('Imagen a color')
plt.axis('off');
plt.tight_layout()
La resolución de la imagen es (539, 589, 3)
In [9]:
# Imagen en blanco y negro.
img_gris = cv2.imread(image2_path, cv2.IMREAD_GRAYSCALE)
print("La resolución de la imagen es {}".format(img_gris.shape))

# Transformar imagen BGR a RGB.
img_gris = cv2.cvtColor(img_gris, cv2.COLOR_BGR2RGB)

plt.imshow(img_gris, cmap='gray')
plt.title('Imagen en escala de grises')
plt.axis('off');
plt.tight_layout()
La resolución de la imagen es (512, 512)
In [11]:
#img_color

plt.figure(figsize=(12, 12))

#Imagen original.
plt.subplot(1,3,1)
plt.imshow(img_color)
plt.title('Imagen original')
plt.axis('off')

# Rotación vertical.
img_color_flip_vert = cv2.flip(img_color, -1)
plt.subplot(1, 3, 2)
plt.imshow(img_color_flip_vert)
plt.title('Imagen rotada verticalmente')
plt.axis('off')
plt.tight_layout()

# Rotación horizontal.
img_color_flip_horz = cv2.flip(img_color, 1)
plt.subplot(1, 3, 3)
plt.imshow(img_color_flip_horz)
plt.title('Imagen rotada horizontalmente')
plt.axis('off');
plt.tight_layout()
In [7]:
plt.figure(figsize=(10, 10))

img_neg = 255 - img_color

plt.subplot(2, 2, 1)
plt.imshow(img_color)
plt.title('Color')
plt.axis('off');

plt.subplot(2, 2, 2)
plt.imshow(img_neg, cmap='gray')
plt.title('Negativo de color')
plt.axis('off');
plt.tight_layout()

In [8]:
plt.figure(figsize=(10, 10))

img_neg = 255 - img_gris

plt.subplot(2, 2, 1)
plt.imshow(img_gris)
plt.title('Color')
plt.axis('off');

plt.subplot(2, 2, 2)
plt.imshow(img_neg, cmap='gray')
plt.title('Negativo de color')
plt.axis('off');
plt.tight_layout()
In [9]:
lx, ly , t= img_color.shape

plt.figure(figsize=(10, 10))

#Imagen original.
plt.subplot(1,2,1)
plt.imshow(img_color)
plt.title('Imagen original')
plt.axis('off')


# Cropping
image_mask = img_color
crop_face = image_mask[lx // 4: - lx // 4, ly // 4: - ly // 4]
plt.subplot(1, 2, 2)
plt.imshow(crop_face)
plt.title('Cropping')
plt.axis('off')
plt.tight_layout()
In [10]:
plt.figure(figsize=(10, 10))
plt.subplot(2, 2, 1)
plt.imshow(img_color); plt.title('Imagen original'); plt.axis('off')

img_out = cv2.edgePreservingFilter(img_color)
plt.subplot(2, 2, 2)
plt.imshow(img_out)
plt.title('Filtro promediado')
plt.axis('off');

img_out = cv2.detailEnhance(img_color);
plt.subplot(2, 2, 3)
plt.imshow(img_out)
plt.title('Realce de detalles')
plt.axis('off');

cv2.stylization(img_color,img_out)
plt.subplot(2, 2, 4)
plt.imshow(img_out)
plt.title('Imagen estilizada')
plt.axis('off');
plt.tight_layout()
In [11]:
plt.figure(figsize=(13, 13))

# Imagen original
plt.subplot(1, 2, 1)
plt.imshow(img_color, cmap='gray') 
plt.axis('off')
plt.title('Imagen original')


t1 = 100
t2 = 200
#Bordes
img_edges = cv2.Canny(img_color, t1, t2)
plt.subplot(1, 2, 2)
plt.imshow(img_edges, cmap='gray')
plt.axis('off')
plt.title('Extracción de bordes');
plt.tight_layout()

Esta y otras funciones proporcionadas por la biblioteca nos permiten detectar los bordes o contornos de una imagen, el resultado se almacena en una imagen binaria.

  1. img_color: imagen de entrada.
  2. t1, t2: son los valores de tolerancia, nos ayudan a limitar los bordes detectados.
In [12]:
plt.figure(figsize=(13, 13))

# Imagen original
plt.subplot(1, 2, 1)
plt.imshow(img_color, cmap='gray') 
plt.axis('off')
plt.title('Imagen original')

#GaussianBlur
img_edges_Blur= cv2.GaussianBlur(img_color, (13,7), 8)
plt.subplot(1, 2, 2)
plt.imshow(img_edges_Blur, cmap='gray')
plt.axis('off')
plt.title('GaussianBlur');
plt.tight_layout()

Esta función la usamos para aplicar un blur a una imagen utilizando un filtro gaussiano, los parÔmetros requeridos son:

  1. img: imagen original.
  2. Size(width, height): tamaƱo del kernel, deben ser positivos e impares.
  3. 8: desviación estÔndar en el eje X.
In [13]:
plt.figure(figsize=(13, 13))

# Imagen original
plt.subplot(1, 2, 1)
plt.imshow(img_color, cmap='gray') 
plt.axis('off')
plt.title('Imagen original')

#GaussianBlur
img_medianBlur= cv2.medianBlur(img_color, 5)
plt.subplot(1, 2, 2)
plt.imshow(img_edges_Blur, cmap='gray')
plt.axis('off')
plt.title('MedianBlur');
plt.tight_layout()

Aplica un blur a la imagen indicada usando el filtro de mediana, los parÔmetros para esta función son:

  1. img: imagen original o de entrada.
  2. 5: tamaƱo del kernel (ksize) debe ser mayor que 1 e impar.

5.7 Erode y Dilate


Estos son funciones que aplican las operaciones morfológicas de erosión y dilatación respectivamente, normalmente son usadas sobre imÔgenes binarias, pero también se pueden utilizar en imÔgenes a color como en el siguiente ejemplo:

In [13]:
kernel = cv2.getStructuringElement(cv2.MORPH_RECT , (7, 7));
In [14]:
plt.figure(figsize=(10, 10))
plt.subplot(2, 2, 1)
plt.imshow(img_color); plt.title('Imagen original'); plt.axis('off')


img_out = cv2.dilate(img_color, kernel);
plt.subplot(2, 2, 2)
plt.imshow(img_out)
plt.title('Dilatacion')
plt.axis('off');

plt.subplot(2, 2, 3)
plt.imshow(img_color); plt.title('Imagen original'); plt.axis('off')


img_out = cv2.erode(img_color, kernel);
plt.subplot(2, 2, 4)
plt.imshow(img_out)
plt.title('Erosion')
plt.axis('off');
plt.tight_layout()
In [15]:
plt.figure(figsize=(10, 10))
plt.subplot(2, 2, 1)
plt.imshow(img_gris); plt.title('Imagen original'); plt.axis('off')


img_out = cv2.dilate(img_gris, kernel);
plt.subplot(2, 2, 2)
plt.imshow(img_out)
plt.title('Dilatacion')
plt.axis('off');

plt.subplot(2, 2, 3)
plt.imshow(img_gris); plt.title('Imagen original'); plt.axis('off')


img_out = cv2.erode(img_gris, kernel);
plt.subplot(2, 2, 4)
plt.imshow(img_out)
plt.title('Erosion')
plt.axis('off');
plt.tight_layout()

6 Guardar una imagen


Una vez hemos procesado la imagen tal vez nos interese guardar en disco una copia de la imagen procesada, OpenCV nos proporciona la función cv2.imwrite() para almacenar una imagen en un archivo indicado, disponemos de distintos formatos como JPG, PNG, TIFF.

In [18]:
path_save = "./images/imagen.png"
In [26]:
#Solo es un proveso para el ejemplo de guardado
t1 = 100
t2 = 200
img_edges = cv2.Canny(img_color, t1, t2)

cv2.imwrite(path_save, img_edges)
Out[26]:
True
In [28]:
Image(filename=path_save) 
Out[28]:

Si te sirvio, COMPARTE!

  • Adios

Mis redes: